package com.mark.util.http;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.net.URLEncoder;
import java.nio.charset.Charset;
import java.security.cert.CertificateException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Map;

import javax.net.ssl.HostnameVerifier;
import javax.net.ssl.SSLContext;
import javax.net.ssl.SSLSession;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;


import com.alibaba.fastjson.JSONObject;
import org.apache.commons.httpclient.HttpException;
import org.apache.commons.httpclient.HttpStatus;
import org.apache.commons.httpclient.methods.GetMethod;
import org.apache.commons.lang3.StringUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.http.*;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.*;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.entity.StringEntity;
import org.apache.http.entity.mime.HttpMultipartMode;
import org.apache.http.entity.mime.MultipartEntity;
import org.apache.http.entity.mime.content.FileBody;
import org.apache.http.entity.mime.content.StringBody;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicHeader;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.params.HttpConnectionParams;
import org.apache.http.params.HttpParams;
import org.apache.http.util.EntityUtils;
import org.codehaus.jackson.map.ObjectMapper;

public class HttpsUtil {
    private static final Log logger = LogFactory.getLog(HttpsUtil.class);

    public static final String CHARACTER_ENCODING = "UTF-8";
    public static final String PATH_SIGN = "/";
    public static final String METHOD_POST = "POST";
    public static final String METHOD_GET = "GET";
    public static final String CONTENT_TYPE = "Content-Type";

    public static final int CONNECTION_TIMEOUT = 10000;
    public static final int SO_TIMEOUT = 60000;
    public static final int SO_TIMEOUT_60S = 60000;

    public static final int BUFFER = 1024;

    /**
     * HttpResponse包装类
     * 
     * @author qiuguobin
     */
    public static class HttpResponseWrapper {
        private HttpResponse httpResponse;
        private HttpClient httpClient;
        private HttpRequestBase httpRequest;

        public HttpResponseWrapper(HttpClient httpClient) {
            this.httpClient = httpClient;
        }

        public HttpResponseWrapper(HttpClient httpClient, HttpResponse httpResponse) {
            this.httpClient = httpClient;
            this.httpResponse = httpResponse;
        }

        public HttpResponseWrapper(HttpClient httpClient, HttpResponse httpResponse, HttpRequestBase httpRequest) {
            this(httpClient, httpResponse);
            this.httpRequest = httpRequest;
        }

        public HttpRequestBase getHttpRequest() {
            return httpRequest;
        }

        public void setHttpRequest(HttpRequestBase httpRequest) {
            this.httpRequest = httpRequest;
        }

        public HttpResponse getHttpResponse() {
            return httpResponse;
        }

        public void setHttpResponse(HttpResponse httpResponse) {
            this.httpResponse = httpResponse;
        }

        /**
         * 获得流类型的响应
         */
        public InputStream getResponseStream() throws IllegalStateException, IOException {
            return httpResponse.getEntity().getContent();
        }

        /**
         * 获得字符串类型的响应
         */
        public String getResponseString(String responseCharacter) throws ParseException, IOException {
            HttpEntity entity = getEntity();
            String responseStr = EntityUtils.toString(entity, responseCharacter);
            if (entity.getContentType() == null) {
                responseStr = new String(responseStr.getBytes("iso-8859-1"), responseCharacter);
            }
            EntityUtils.consume(entity);
            return responseStr;
        }

        public String getResponseString() throws ParseException, IOException {
            return getResponseString(CHARACTER_ENCODING);
        }

        /**
         * 获得响应状态码
         */
        public int getStatusCode() {
            return httpResponse.getStatusLine().getStatusCode();
        }

        /**
         * 获得响应状态码并释放资源
         */
        public int getStatusCodeAndClose() {
            close();
            return getStatusCode();
        }

        public HttpEntity getEntity() {
            return httpResponse.getEntity();
        }

        /**
         * 释放资源
         */
        public void close() {
            if (httpRequest != null) {
                httpRequest.releaseConnection();
            }
            httpClient.getConnectionManager().shutdown();
        }
    }

    /**
     * POST方式提交上传文件请求
     */
    public static HttpResponseWrapper requestPostUpload(String url, Map<String, File> requestFiles, Map<String, String> requestParas, String requestCharacter)
            throws ClientProtocolException, IOException {
        HttpClient client = null;
        if (url.startsWith("https")) {
            client = createHttpsClient();
        } else {
            client = createHttpClient();
        }
        HttpPost httpPost = new HttpPost(url);
        MultipartEntity multipartEntity = new MultipartEntity(HttpMultipartMode.BROWSER_COMPATIBLE, null, Charset.forName(requestCharacter));
        if (requestFiles == null || requestFiles.size() == 0) {
            return null;
        }
        for (Map.Entry<String, File> entry : requestFiles.entrySet()) {
            multipartEntity.addPart(entry.getKey(), new FileBody(entry.getValue(), "application/octet-stream", requestCharacter));
        }
        if (requestParas != null && requestParas.size() > 0) {
            // 对key进行排序
            List<String> keys = new ArrayList<String>(requestParas.keySet());
            Collections.sort(keys);
            for (String key : keys) {
                multipartEntity.addPart(key, new StringBody(requestParas.get(key), Charset.forName(requestCharacter)));
            }
        }
        httpPost.setEntity(multipartEntity);

        try {
            HttpResponse httpResponse = client.execute(httpPost);
            return new HttpResponseWrapper(client, httpResponse, httpPost);
        } catch (Exception e) {
            logger.error(e);
        }
        return null;
    }

    /**
     * POST方式提交上传文件请求
     */
    public static HttpResponseWrapper requestPostUpload(String url, Map<String, File> requestFiles, Map<String, String> requestParas) throws ClientProtocolException, IOException {
        return requestPostUpload(url, requestFiles, requestParas, CHARACTER_ENCODING);
    }

    /**
     * POST方式提交表单数据，返回响应对象
     */
    public static HttpResponseWrapper requestPostFormResponse(String url, Map<String, Object> requestParas, String requestCharacter) throws ClientProtocolException, IOException {
        HttpClient client = null;
        if (url.startsWith("https")) {
            client = createHttpsClient();
        } else {
            client = createHttpClient();
        }
        HttpPost httpPost = new HttpPost(url);
        List<NameValuePair> formParams = covertParams2NameValuePair(requestParas);
        httpPost.setEntity(new UrlEncodedFormEntity(formParams, requestCharacter));

        try {
            HttpResponse httpResponse = client.execute(httpPost); // 执行POST请求
            return new HttpResponseWrapper(client, httpResponse, httpPost);
        } catch (Exception e) {
            logger.error(e);
        }
        return null;
    }

    /**
     * 自定义操作表单提交的数据
     * 
     * @return
     */
    public static HttpResponseWrapper requestPostFormResponse2(String url, Map<String, Object> requestParas, int timeOut) throws IOException, HttpException {
        HttpClient client = null;
        if (url.startsWith("https")) {
            client = createHttpsClient(CONNECTION_TIMEOUT, timeOut * 1000);
        } else {
            client = createHttpClient(CONNECTION_TIMEOUT, timeOut * 1000);
        }
        // client.getParams().setParameter("Accept-Encoding", "gzip, deflate");
        HttpPost httpPost = new HttpPost(url);
        List<NameValuePair> formParams = covertParams2NameValuePair(requestParas);
        httpPost.setEntity(new UrlEncodedFormEntity(formParams, CHARACTER_ENCODING));

        try {
            HttpResponse httpResponse = client.execute(httpPost); // 执行POST请求
            return new HttpResponseWrapper(client, httpResponse, httpPost);
        } catch (Exception e) {
            logger.error(e);
        }
        return null;
    }

    /**
     * POST方式提交表单数据，返回响应对象，utf8编码
     */
    public static HttpResponseWrapper requestPostFormResponse(String url, Map<String, Object> requestParas) throws ClientProtocolException, IOException {
        return requestPostFormResponse(url, requestParas, CHARACTER_ENCODING);
    }

    /**
     * POST方式提交表单数据，不会自动重定向
     */
    public static String requestPostForm(String url, Map<String, Object> requestParas, String requestCharacter, String responseCharacter) {
        HttpResponseWrapper httpResponseWrapper = null;
        try {
            httpResponseWrapper = requestPostFormResponse(url, requestParas, requestCharacter);
            return httpResponseWrapper.getResponseString(responseCharacter);
        } catch (Exception e) {
            logger.error(e);
        } finally {
            httpResponseWrapper.close();
        }
        return null;
        // HttpClient client = null;
        // String responseStr = null;
        // try{
        // if (url.startsWith("https")) {
        // client =createHttpsClient();
        // }else{
        // client =createHttpClient();
        // }
        // HttpPost httpPost = new HttpPost(url);
        // List<NameValuePair> formParams = covertParams2NameValuePair(requestParas);
        // httpPost.setEntity(new UrlEncodedFormEntity(formParams,
        // requestCharacter));
        // HttpResponse httpResponse = client.execute(httpPost); //执行POST请求
        // int statusCode = httpResponse.getStatusLine().getStatusCode();
        // if (isRedirectStatus(statusCode)) {
        // httpPost.abort();
        // Header locationHeader = httpResponse.getFirstHeader("location");
        // if (locationHeader != null) {
        // String location = locationHeader.getValue();
        // logger.info("redirect url=" + location);
        // HttpGet httpGet = new HttpGet(location);
        // HttpResponse response = client.execute(httpGet);
        // HttpEntity entity = response.getEntity();
        // if (entity!=null) {
        // responseStr = EntityUtils.toString(entity, responseCharacter);
        // EntityUtils.consume(entity);
        // }
        // }
        // } else {
        // HttpEntity entity = httpResponse.getEntity(); //获取响应实体
        // if (entity!=null) {
        // responseStr = EntityUtils.toString(entity, responseCharacter);
        // EntityUtils.consume(entity);
        // }
        // }
        // }catch(IOException e) {
        // logger.error(e.getMessage());
        // e.printStackTrace();
        // }finally {
        // client.getConnectionManager().shutdown();
        // }
        // return responseStr;
    }

    /**
     * POST方式提交表单数据，不会自动重定向
     */
    public static String requestPostForm(String url, Map<String, Object> requestParas) {
        return requestPostForm(url, requestParas, CHARACTER_ENCODING, CHARACTER_ENCODING);
    }

    public static String requestPostFormOwnSetTimeOut(String url, Map<String, Object> requestParas, int timeout) {
        return requestPostFormOwnSetTimeOut(url, requestParas, CHARACTER_ENCODING, CHARACTER_ENCODING, timeout);
    }

    public static String requestPostFormOwnSetTimeOut(String url, Map<String, Object> requestParas, String requestCharacter, String responseCharacter, int timeout) {
        HttpResponseWrapper httpResponseWrapper = null;
        try {
            httpResponseWrapper = requestPostFormOwnSetTimeOut(url, requestParas, requestCharacter, timeout);
            return httpResponseWrapper.getResponseString(responseCharacter);
        } catch (Exception e) {
            logger.error(e);
        } finally {
            httpResponseWrapper.close();
        }
        return null;
    }

    public static HttpResponseWrapper requestPostFormOwnSetTimeOut(String url, Map<String, Object> requestParas, String requestCharacter, int timeout)
            throws ClientProtocolException, IOException {
        HttpClient client = null;
        if (url.startsWith("https")) {
            client = createHttpsClientOwnSetTimeOut(timeout);
        } else {
            client = createHttpClientOwnSetTimeOut(timeout);
        }
        HttpPost httpPost = new HttpPost(url);
        List<NameValuePair> formParams = covertParams2NameValuePair(requestParas);
        httpPost.setEntity(new UrlEncodedFormEntity(formParams, requestCharacter));

        try {
            HttpResponse httpResponse = client.execute(httpPost); // 执行POST请求
            return new HttpResponseWrapper(client, httpResponse, httpPost);
        } catch (Exception e) {
            logger.error(e);
        }
        return null;
    }

    // private static boolean isRedirectStatus(int statuscode) {
    // return (statuscode == HttpStatus.SC_MOVED_PERMANENTLY) ||
    // (statuscode == HttpStatus.SC_MOVED_TEMPORARILY) ||
    // (statuscode == HttpStatus.SC_SEE_OTHER) ||
    // (statuscode == HttpStatus.SC_TEMPORARY_REDIRECT);
    // }

    public static HttpResponseWrapper requestGetResponse(String url) throws ClientProtocolException, IOException {
        HttpClient client = null;
        if (url.startsWith("https")) {
            client = createHttpsClient();
        } else {
            client = createHttpClient();
        }
        HttpGet httpGet = new HttpGet(url);

        try {
            HttpResponse httpResponse = client.execute(httpGet);
            return new HttpResponseWrapper(client, httpResponse, httpGet);
        } catch (Exception e) {
            logger.error(e);
        }
        return null;
    }

    public static HttpResponseWrapper requestGetResponse(String url, String xForWardedFor) throws ClientProtocolException, IOException {
        HttpClient client = null;
        if (url.startsWith("https")) {
            client = createHttpsClient();
        } else {
            client = createHttpClient();
        }
        HttpGet httpGet = new HttpGet(url);
        if (StringUtils.isNotEmpty(xForWardedFor)) {
            httpGet.addHeader("X-Forwarded-For", xForWardedFor);
        }

        try {
            HttpResponse httpResponse = client.execute(httpGet);
            return new HttpResponseWrapper(client, httpResponse, httpGet);
        } catch (Exception e) {
            logger.error(e);
        }
        return null;
    }

    /**
     * GET方式提交URL请求，会自动重定向
     */
    public static String requestGet(String url, String responseCharacter, String xForWardedFor) {
        HttpResponseWrapper httpResponseWrapper = null;
        try {
            httpResponseWrapper = requestGetResponse(url, xForWardedFor);
            return httpResponseWrapper.getResponseString(responseCharacter);
        } catch (Exception e) {
            logger.error(e);
        } finally {
            if (httpResponseWrapper != null) {
                httpResponseWrapper.close();
            }
        }
        return null;
    }

    /**
     * GET方式提交URL请求，会自动重定向
     */
    public static String requestGet(String url) {
        return requestGet(url, CHARACTER_ENCODING, null);
    }

    /**
     * get请求
     * 
     * @param url
     *            请求url(eg:https://api.lvmama.com/user/getUserInfo)
     * @param params
     *            参数
     * @return 响应信息
     */
    public static String requestGet(String url, Map<String, Object> params) {
        StringBuilder urlBuilder = new StringBuilder(url);
        urlBuilder.append("?").append(mapToUrl(params));
        return requestGet(urlBuilder.toString(), CHARACTER_ENCODING, null);
    }

    /**
     * 将Map中的数据组装成url
     * 
     * @param params
     * @return
     */
    public static String mapToUrl(Map<String, Object> params) {
        StringBuilder sb = new StringBuilder();
        try {
            boolean isFirst = true;
            for (String key : params.keySet()) {
                String value = (String) params.get(key);
                if (isFirst) {
                    sb.append(key + "=" + URLEncoder.encode(value, "utf-8"));
                    isFirst = false;
                } else {
                    if (value != null) {
                        sb.append("&" + key + "=" + URLEncoder.encode(value, "utf-8"));
                    } else {
                        sb.append("&" + key + "=");
                    }
                }
            }
        } catch (Exception e) {
            logger.error(e);
        }
        return sb.toString();
    }

    /**
     * 将Map中的数据组装成url
     * 
     * @param params
     * @return
     */
    public static String mapToUrl(Map<String, Object> params, String encodeCharacter) {
        StringBuilder sb = new StringBuilder();
        try {
            boolean isFirst = true;
            for (String key : params.keySet()) {
                String value = (String) params.get(key);
                if (isFirst) {
                    sb.append(key + "=" + URLEncoder.encode(value, encodeCharacter));
                    isFirst = false;
                } else {
                    if (value != null) {
                        sb.append("&" + key + "=" + URLEncoder.encode(value, encodeCharacter));
                    } else {
                        sb.append("&" + key + "=");
                    }
                }
            }
        } catch (Exception e) {
            logger.error(e);
        }
        return sb.toString();
    }

    /**
     * GET方式提交URL请求，会自动重定向
     */
    public static String proxyRequestGet(String url, String xForWardedFor) {
        return requestGet(url, CHARACTER_ENCODING, xForWardedFor);
    }

    /**
     * POST方式提交非表单数据，返回响应对象
     */
    public static HttpResponseWrapper requestPostData(String url, String data, String contentType, String requestCharacter, int connectionTimeout, int soTimeout)
            throws ClientProtocolException, IOException {
        HttpClient client = null;
        HttpPost httpPost = null;
        if (url.startsWith("https")) {
            client = createHttpsClient(connectionTimeout, soTimeout);
        } else {
            client = createHttpClient(connectionTimeout, soTimeout);
        }
        httpPost = new HttpPost(url);
        httpPost.setHeader(CONTENT_TYPE, contentType);
        httpPost.setEntity(new StringEntity(data, requestCharacter));

        try {
            HttpResponse httpResponse = client.execute(httpPost);
            return new HttpResponseWrapper(client, httpResponse, httpPost);
        } catch (Exception e) {
            logger.error(e);
        } finally {
            // httpPost.releaseConnection();
        }
        return null;
    }

    /**
     * POST方式提交非表单数据，返回响应对象
     */
    public static HttpResponseWrapper requestPostData(String url, String data, String contentType, String requestCharacter) throws ClientProtocolException, IOException {
        return requestPostData(url, data, contentType, requestCharacter, CONNECTION_TIMEOUT, SO_TIMEOUT);
    }

    /**
     * POST非表单方式提交XML数据
     */
    public static String requestPostXml(String url, String xmlData, String requestCharacter, String responseCharacter) {
        HttpResponseWrapper httpResponseWrapper = null;
        try {
            String contentType = "text/xml; charset=" + requestCharacter;
            httpResponseWrapper = requestPostData(url, xmlData, contentType, requestCharacter);
            return httpResponseWrapper.getResponseString(responseCharacter);
        } catch (Exception e) {
            logger.error(e);
        } finally {
            httpResponseWrapper.close();
        }
        return null;
    }

    /**
     * POST非表单方式提交XML数据
     */
    public static String requestPostXml(String url, String xmlData) {
        return requestPostXml(url, xmlData, CHARACTER_ENCODING, CHARACTER_ENCODING);
    }

    public static HttpClient createHttpClient(int connectionTimeout, int soTimeout) {
        HttpClient httpClient = new DefaultHttpClient();
        HttpParams params = httpClient.getParams();
        HttpConnectionParams.setConnectionTimeout(params, connectionTimeout);
        HttpConnectionParams.setSoTimeout(params, soTimeout);
        return httpClient;
    }

    public static HttpClient createHttpClient() {
        return createHttpClient(CONNECTION_TIMEOUT, SO_TIMEOUT);
    }

    public static HttpClient createHttpClientOwnSetTimeOut(int timeout) {
        return createHttpClient(timeout, timeout);
    }

    public static HttpClient createHttpsClient(int connectionTimeout, int soTimeout) {
        try {
            HttpClient httpClient = new DefaultHttpClient(); // 创建默认的httpClient实例
            HttpParams params = httpClient.getParams();
            HttpConnectionParams.setConnectionTimeout(params, connectionTimeout);
            HttpConnectionParams.setSoTimeout(params, soTimeout);
            // TLS1.0与SSL3.0基本上没有太大的差别，可粗略理解为TLS是SSL的继承者，但它们使用的是相同的SSLContext
            SSLContext ctx = SSLContext.getInstance("TLS");
            // 使用TrustManager来初始化该上下文，TrustManager只是被SSL的Socket所使用
            ctx.init(null, new TrustManager[] { new TrustAnyTrustManager() }, null);
            // 创建SSLSocketFactory
            SSLSocketFactory socketFactory = new SSLSocketFactory(ctx);
            // 通过SchemeRegistry将SSLSocketFactory注册到我们的HttpClient上
            httpClient.getConnectionManager().getSchemeRegistry().register(new Scheme("https", 443, socketFactory));
            return httpClient;
        } catch (Exception e) {
            logger.error(e);
        }
        return null;
    }

    public static HttpClient createHttpsClient() {
        return createHttpsClient(CONNECTION_TIMEOUT, SO_TIMEOUT);
    }

    public static HttpClient createHttpsClientOwnSetTimeOut(int timeout) {
        return createHttpsClient(timeout, timeout);
    }

    /**
     * 转换参数列表为NameValuePair
     * @param params
     * @return
     */
    public static List<NameValuePair> covertParams2NameValuePair(Map<String, Object> params) {
        List<NameValuePair> formParams = new ArrayList<NameValuePair>();
        if (params != null && params.size() > 0) {
//            // 对key进行排序
//            List<String> keys = new ArrayList<String>(params.keySet());
//            Collections.sort(keys);
//            for (String key : keys) {
//                // logger.info(key+" = " +params.get(key));
//                formParams.add(new BasicNameValuePair(key, params.get(key)));
//            }
            //优化
            for (Map.Entry<String,Object> param:params.entrySet()){
                formParams.add(new BasicNameValuePair(param.getKey(),String.valueOf(param.getValue())));
            }
        }
        return formParams;
    }

    /**
     * 通过httpclient下载的文件直接转为字节数组
     * 
     * @param path
     * @author yanzhirong
     * @return
     */
    public static byte[] getHttpClientResponseByteArray(String path) {
        org.apache.commons.httpclient.HttpClient client = new org.apache.commons.httpclient.HttpClient();
        GetMethod httpGet = new GetMethod(path);

        byte[] byteArrays = new byte[0];
        InputStream in = null;
        ByteArrayOutputStream bos = null;
        try {
            client.executeMethod(httpGet);
            in = httpGet.getResponseBodyAsStream();
            bos = new ByteArrayOutputStream();

            byte[] b = new byte[BUFFER];
            int len = 0;
            while ((len = in.read(b)) != -1) {
                bos.write(b, 0, len);
            }
            byteArrays = bos.toByteArray();
            in.close();
            bos.close();
        } catch (Exception e) {
            logger.error(e);
        } finally {
            httpGet.releaseConnection();
            try {
                if (in != null) {
                    in.close();
                }
                if (bos != null) {
                    bos.close();
                }
            } catch (IOException e1) {
                logger.error(e1);
            }
        }
        return byteArrays;
    }

    private static class TrustAnyHostnameVerifier implements HostnameVerifier {
        public boolean verify(String hostname, SSLSession session) {
            return true;
        }
    }

    private static class TrustAnyTrustManager implements X509TrustManager {

        public void checkClientTrusted(X509Certificate[] chain, String authType) throws CertificateException {
        }

        public void checkServerTrusted(X509Certificate[] chain, String authType) throws CertificateException {
        }

        public X509Certificate[] getAcceptedIssuers() {
            return new X509Certificate[] {};
        }
    }

    /******************** 已下为客户端新加 2014-05-29 *****************/
    /**
     * 客户端调用 POST方式提交表单数据，不会自动重定向
     * 
     * @param url
     *            请求url
     * @param requestParas
     *            请求参数
     * @param xForWardedFor
     *            请求ip（统计客户端登陆次数）
     * 
     */
    public static String requestPostForm(String url, Map<String, Object> requestParas, String xForWardedFor) {
        return requestPostForm(url, requestParas, xForWardedFor, CHARACTER_ENCODING, CHARACTER_ENCODING);
    }

    /**
     * 客户端登陆调用
     * 
     * @param url
     *            请求url
     * @param requestParas
     *            请求参数
     * @param xForWardedFor
     *            请求ip（统计客户端登陆次数）
     * @param requestCharacter
     *            请求编码
     * @param responseCharacter
     *            响应编码
     * @return
     */
    public static String requestPostForm(String url, Map<String, Object> requestParas, String xForWardedFor, String requestCharacter, String responseCharacter) {
        HttpResponseWrapper httpResponseWrapper = null;
        try {
            httpResponseWrapper = requestPostFormResponse(url, requestParas, requestCharacter, xForWardedFor);
            return httpResponseWrapper.getResponseString(responseCharacter);
        } catch (Exception e) {
            logger.error(e);
        } finally {
            httpResponseWrapper.close();
        }
        return null;
    }

    /**
     * POST方式提交表单数据，返回响应对象
     * 
     * @param url
     *            请求url
     * @param requestParas
     *            请求参数
     * @param xForWardedFor
     *            请求ip（统计客户端登陆次数）
     */
    public static HttpResponseWrapper requestPostFormResponse(String url, Map<String, Object> requestParas, String requestCharacter, String xForWardedFor)
            throws ClientProtocolException, IOException {
        HttpClient client = null;
        if (url.startsWith("https")) {
            client = createHttpsClient();
        } else {
            client = createHttpClient();
        }
        HttpPost httpPost = new HttpPost(url);
        if (StringUtils.isNotEmpty(xForWardedFor)) {
            httpPost.addHeader("X-Forwarded-For", xForWardedFor);
        }
        List<NameValuePair> formParams = covertParams2NameValuePair(requestParas);
        httpPost.setEntity(new UrlEncodedFormEntity(formParams, requestCharacter));

        try {
            HttpResponse httpResponse = client.execute(httpPost); // 执行POST请求
            return new HttpResponseWrapper(client, httpResponse, httpPost);
        } catch (Exception e) {
            logger.error(e);
        } finally {
            // httpPost.releaseConnection();
        }
        return null;
    }

    public static HttpClient createHttpClient(Map<String, Object> httpParams) {
        HttpClient httpClient = new DefaultHttpClient();
        HttpParams params = httpClient.getParams();
        if (params != null && httpParams != null) {
            for (String key : httpParams.keySet()) {
                params.setParameter(key, httpParams.get(key));
            }
        }
        return httpClient;
    }

    public static HttpClient createHttpsClient(Map<String, Object> httpParams) {
        try {
            HttpClient httpClient = new DefaultHttpClient(); // 创建默认的httpClient实例
            HttpParams params = httpClient.getParams();
            if (params != null && httpParams != null) {
                for (String key : httpParams.keySet()) {
                    params.setParameter(key, httpParams.get(key));
                }
            }
            // TLS1.0与SSL3.0基本上没有太大的差别，可粗略理解为TLS是SSL的继承者，但它们使用的是相同的SSLContext
            SSLContext ctx = SSLContext.getInstance("TLS");
            // 使用TrustManager来初始化该上下文，TrustManager只是被SSL的Socket所使用
            ctx.init(null, new TrustManager[] { new TrustAnyTrustManager() }, null);
            // 创建SSLSocketFactory
            SSLSocketFactory socketFactory = new SSLSocketFactory(ctx);
            // 通过SchemeRegistry将SSLSocketFactory注册到我们的HttpClient上
            httpClient.getConnectionManager().getSchemeRegistry().register(new Scheme("https", 443, socketFactory));
            return httpClient;
        } catch (Exception e) {
            logger.error(e);
        }
        return null;
    }

    /**
     * 
     * @autor: heyuxing 2014-11-14 下午8:02:50
     * @param url
     *            请求url
     * @param params
     *            请求参数
     * @param httpParams
     *            设置HttpClient.getParams()中的参数
     * @return
     * @return String
     */
    public static String requestGet(String url, Map<String, Object> params, Map<String, Object> httpParams) {
        return requestGet(url, params, httpParams, null);
    }

    /**
     * 
     * @autor: heyuxing 2014-12-11 下午2:29:01
     * @param url
     *            请求url
     * @param params
     *            请求参数
     * @param httpParams
     *            设置HttpClient.getParams()中的参数
     * @param responseCharacter
     *            处理应答response字符串使用的字符集
     * @return
     * @return String
     */
    public static String requestGet(String url, Map<String, Object> params, Map<String, Object> httpParams, String responseCharacter) {
        StringBuilder urlBuilder = new StringBuilder(url);
        urlBuilder.append("?").append(mapToUrl(params));

        HttpResponseWrapper httpResponseWrapper = null;
        HttpGet httpGet = null;
        HttpClient client = null;
        try {

            if (url.startsWith("https")) {
                client = createHttpsClient(httpParams);
            } else {
                client = createHttpClient(httpParams);
            }
            httpGet = new HttpGet(urlBuilder.toString());
            HttpResponse httpResponse = client.execute(httpGet);

            if (StringUtils.isEmpty(responseCharacter)) {
                responseCharacter = CHARACTER_ENCODING;
            }
            return new HttpResponseWrapper(client, httpResponse, httpGet).getResponseString(responseCharacter);
        } catch (Exception e) {
            logger.error(e);
        } finally {
            if (httpResponseWrapper != null) {
                httpResponseWrapper.close();
            }
            if (httpGet != null) {
                httpGet.releaseConnection();
            }
        }
        return null;
    }

    /**
     * 
     * @autor: mahy 2015-10-21 下午2:29:01
     * @param url
     *            请求url
     * @param params
     *            请求参数
     * @param httpParams
     *            设置HttpClient.getParams()中的参数
     * @param responseCharacter
     *            处理应答response字符串使用的字符集
     * @return
     * @return String
     */
    public static String requestGet(String url, Map<String, Object> params, Map<String, Object> httpParams, String requestCharacter, String responseCharacter) {
        StringBuilder urlBuilder = new StringBuilder(url);
        urlBuilder.append("?").append(mapToUrl(params, requestCharacter));

        HttpResponseWrapper httpResponseWrapper = null;
        HttpGet httpGet = null;
        HttpClient client = null;
        try {

            if (url.startsWith("https")) {
                client = createHttpsClient(httpParams);
            } else {
                client = createHttpClient(httpParams);
            }
            httpGet = new HttpGet(urlBuilder.toString());
            HttpResponse httpResponse = client.execute(httpGet);

            if (StringUtils.isEmpty(responseCharacter)) {
                responseCharacter = CHARACTER_ENCODING;
            }
            return new HttpResponseWrapper(client, httpResponse, httpGet).getResponseString(responseCharacter);
        } catch (Exception e) {
            logger.error(e);
        } finally {
            if (httpResponseWrapper != null) {
                httpResponseWrapper.close();
            }
            if (httpGet != null) {
                httpGet.releaseConnection();
            }
        }
        return null;
    }

    public static Object requestRestGet(String url, Class Voclass) {
        try {
            CloseableHttpClient httpClient = HttpClients.createDefault();

            HttpGet httpGet = new HttpGet(url);

            httpGet.setHeader(new BasicHeader("Accept", "application/json"));

            HttpResponse httpResponse = httpClient.execute(httpGet);
            HttpEntity entity = httpResponse.getEntity();
            ObjectMapper mapper = new ObjectMapper();
            System.out.println(entity.getContent());

            Object details = mapper.readValue(entity.getContent(), Voclass);
            logger.info(details);
            return details;
        } catch (Exception e) {
            logger.error("", e);
        }
        return null;
    }

    /**
     *
     * @param url
     * @param Voclass
     * @return
     */
    public static Object requestRestPost(String url, Class Voclass) {
        try {
            HttpResponseWrapper responseWrapper = requestPostData(url, null, "application/json", "UTF-8");
            if (responseWrapper == null) {
                logger.info("PreSaleRefundApplyServiceTaskImpl.updateStampCode responseWrapper is null");
            }
            if (responseWrapper != null) {
                int statusCode = responseWrapper.getStatusCode();// 请求返回的状态码
                logger.info("preSaleOrder返回状态码：" + statusCode);
                if (statusCode != HttpStatus.SC_OK) {
                    logger.info("preSaleOrder返回状态码：" + statusCode + " 返回字符串为" + responseWrapper.getResponseString());
                }
            }

            return JSONObject.parseObject(responseWrapper.getResponseString());

        } catch (Exception e) {
            logger.error("", e);
        }
        return null;
    }

    /**
     *
     * @param url
     * @param Voclass
     * @return
     */
    public static Object requestRestPostMapper(String url, Class Voclass) {
        try {
            CloseableHttpClient httpClient = HttpClients.createDefault();

            HttpPost httpPost = new HttpPost(url);

            httpPost.setHeader(new BasicHeader("Accept", "application/json"));

            CloseableHttpResponse httpResponse = httpClient.execute(httpPost);
            HttpEntity entity = httpResponse.getEntity();
            ObjectMapper mapper = new ObjectMapper();
            System.out.println(entity.getContent());

            Object details = mapper.readValue(entity.getContent(), Voclass);
            return details;
        } catch (Exception e) {
            logger.error("", e);
        }
        return null;
    }

    /**
     * PUT方式提交非表单数据，返回响应对象 add by zoubin
     */
    public static HttpResponseWrapper requestPutData(String url, String data, String contentType, String requestCharacter, int connectionTimeout, int soTimeout)
            throws ClientProtocolException, IOException {
        HttpClient client = null;
        HttpPut httpPut = null;
        if (url.startsWith("https")) {
            client = createHttpsClient(connectionTimeout, soTimeout);
        } else {
            client = createHttpClient(connectionTimeout, soTimeout);
        }
        httpPut = new HttpPut(url);

        httpPut.setHeader(CONTENT_TYPE, contentType);
        httpPut.setEntity(new StringEntity(data, requestCharacter));

        try {
            HttpResponse httpResponse = client.execute(httpPut);
            return new HttpResponseWrapper(client, httpResponse, httpPut);
        } catch (Exception e) {
            logger.error(e);
        } finally {
            // httpPost.releaseConnection();
        }
        return null;
    }

    public static void main(String[] args) throws ClientProtocolException, IOException {
        // String url = Constant.PRE_SELL_SERVICE +
        // "/back/stamp/refund/apply?refundId=355686&orderId=200613652&refundNum=1";
        // System.out.println("hhs/v1/back/stamp/refundByCode/apply,url=" +
        // url);

        HttpResponseWrapper responseWrapper = requestPostData(
                "http://10.112.4.203:8181/hhs/v1/back/stamp/refundByCode/apply?refundId=358763&orderId=200614029&stampCodes=4672951888", new JSONObject().toString(),
                "application/json", "UTF-8");
        if (responseWrapper == null) {
            System.out.println("PreSaleRefundApplyServiceTaskImpl.updateStampCode responseWrapper is null");
        }
        if (responseWrapper != null) {
            int statusCode = responseWrapper.getStatusCode();// 请求返回的状态码
            if (statusCode != HttpStatus.SC_OK) {
                System.out.println("preSaleOrder返回状态码：" + statusCode + " 返回字符串为" + responseWrapper.getResponseString());

            }
        }

//        StampRefundResponse stampRefundResponse = (StampRefundResponse) JSONObject.toBean(JSONObject.fromObject(responseWrapper.getResponseString()), StampRefundResponse.class);
//        System.out.println("hhs/v1/back/stamp/refund/apply,StampRefundResponse=" + StringUtil.printParam(stampRefundResponse));

    }

    /**
     * PUT方式提交非表单数据，返回响应对象 add by zoubin
     */
    public static HttpResponseWrapper requestPutData(String url, String data, String contentType, String requestCharacter) throws ClientProtocolException, IOException {
        return requestPutData(url, data, contentType, requestCharacter, CONNECTION_TIMEOUT, SO_TIMEOUT);
    }
}